home *** CD-ROM | disk | FTP | other *** search
/ Dictionaries & Language / Dictionaries and Language (Chestnut CD-ROM) (1993).iso / misc / itrns211 / font.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-10-14  |  31.5 KB  |  1,008 lines
  1. /*
  2.  *========================================================================== 
  3.  * Copyright 1991 Avinash Chopde, All Rights Reserved.
  4.  *
  5.  * Permission to use, copy, modify and distribute this software and its
  6.  * documentation for any purpose is hereby granted without fee, provided that
  7.  * the above copyright notice appear in all copies and that both that
  8.  * copyright notice and this permission notice appear in supporting
  9.  * documentation, and that the name of Avinash Chopde not be used in
  10.  * advertising or publicity pertaining to distribution of the software
  11.  * without specific, written prior permission.
  12.  * Avinash Chopde makes no representations about the suitability of this
  13.  * software for any purpose.
  14.  * It is provided "as is" without express or implied warranty.
  15.  *
  16.  * AVINASH CHOPDE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  17.  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
  18.  * IN NO EVENT SHALL AVINASH CHOPDE BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  19.  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  20.  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  21.  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  22.  * OF THIS SOFTWARE.
  23.  *
  24.  * Author:  Avinash Chopde, 1991
  25.  *        C2 Colonial Drive #4, Andover, MA 01810, USA.
  26.  *
  27.  */
  28.  
  29. #include "itrans.h"
  30. #include "ifm.h"
  31.  
  32. static char S_RCSID[] = "$Header: e:/itrans/src/rcs/font.c 1.11 91/10/14 00:40:13 avinash Exp $";
  33.  
  34. /* definitions used by decode_name() */
  35. #define    ALL_CHARS    -1
  36.     /* ALL_CHARS must be zero-1, see decode_name() */
  37. #define    NO_CHAR        -2
  38.  
  39. /* =================================================================== */
  40. static int S_ccadd(FILE* ifmfp);
  41. static void S_clear_ccadds();
  42. static int S_ccs(FILE* ifmfp, font_t *font);
  43. static int S_cc(FILE* ifmfp, font_t *font);
  44. static int S_prop(FILE* ifmfp, font_t *font);
  45. static int S_fillup_ps(FILE* afmfp, font_t* font);
  46. static int S_fillup_tfm(font_t* font);
  47.  
  48. /* The extra_map[] stores user defined khadi names --
  49.  * these are only used in "same-as" (CCS) IFM tag
  50.  * Cannot be generated directly by the user.
  51.  * See also the definition of G_ifm_map ahead in this file.....
  52.  */
  53. static ifm_enc_t S_ifm_extra_map[NUMEXTRA];
  54.  
  55. /* =================================================================== */
  56. /* initialise font with empty values */
  57. void init_font(font_t* font)
  58. {
  59.     int i, j;
  60.  
  61.     font->prop = UNDEF_FONT;
  62.     font->name[0] = '\0';
  63.     font->fname[0] = '\0';
  64.     font->use_ligatures = TRUE;
  65.  
  66.     for (i = 0; i < NUMKHADI; i ++) {
  67.     font->khadi[i].cus = NULL;
  68.     font->khadi[i].same_as = NULL;
  69.     }
  70.  
  71.     for (i = 0; i < NUMCHARS; i ++) {
  72.         for (j = 0; j < NUMCHARS; j ++) {
  73.         font->ligatures[i][j].cus = NULL;
  74.         font->ligatures[i][j].same_as = NULL;
  75.         }
  76.     }
  77.     for (i = 0; i < 10; i ++) {
  78.     font->digits[i].cus = NULL;
  79.     font->digits[i].same_as = NULL;
  80.     }
  81.  
  82.     for (i = 0; i < NUMPSCHARS; i ++) {
  83.     font->psfm[i].w = 0;
  84.     font->psfm[i].llx = 0;
  85.     font->psfm[i].lly = 0;
  86.     font->psfm[i].urx = 0;
  87.     font->psfm[i].ury = 0;
  88.     }
  89. } /* init_font() */
  90.  
  91. /* =================================================================== */
  92. font_t*    find_font(allfonts_t af, char fname[])
  93. {
  94.     font_t* f;
  95.     int i;
  96.  
  97. #ifdef DEBUG
  98.     fprintf(stderr, "looking for font %s\n", fname);
  99. #endif
  100.  
  101.     f = NULL;
  102.     for (i = 0; i < FONTS_MAX;  i ++) {
  103.  
  104. #ifdef DEBUG
  105.     if (af[i]) fprintf(stderr, "found font %s\n", af[i]->fname);
  106. #endif
  107.  
  108.     if (af[i] && !strcmp(fname, af[i]->fname)) {
  109.        f = af[i];
  110.        break;
  111.     }
  112.     }
  113.     return f;
  114. }
  115. /* =================================================================== */
  116. /* fillup the font data by reading in the IFM file supplied */
  117. /* assumed that init_font() has been called before.... */
  118.  
  119. int fillup_font(font_t* font, char ifmfname[])
  120. {
  121.     int        i;
  122.     char    word[256];
  123.     char    ifmword[256];
  124.     int        ifmtoken;
  125.     char    fmfname[NAMELEN];
  126.     FILE*    fmfp;
  127.     char*    ienv;
  128.     char*    dp;
  129.     FILE*    ifmfp;
  130.     int        errflg= 0;
  131.     
  132.     /* get the search path... */
  133.     ienv = getenv(ITRANS_PATH);
  134.     if (!ienv) {
  135.     putenv(ITRANS_PATH_DEF);
  136.         ienv = getenv(ITRANS_PATH);
  137.     if (!ienv) { /* STUPID ERROR, SYSTEM PROBLEM.. */
  138.         ienv = strchr(ITRANS_PATH_DEF, '=') + 1;
  139.     }
  140.     }
  141.  
  142.     if ( !font ) {
  143.     fprintf(stderr, "Program error (malloc failed ?): fillup_font() got NULL font\n");
  144.     return FALSE;
  145.     }
  146.  
  147.     ifmfp = search_fopen(ienv, ifmfname, "r");
  148.     if (!ifmfp) {
  149.      fprintf(stderr, "Error: could not open %s for reading\n", ifmfname);
  150.      return FALSE;
  151.     }
  152.  
  153.     /* -------- FILLUP khadi */
  154.     /* FILL UP THE DEVNAGARI CHARS */
  155.  
  156.     reset_pifm(); /* reset the IFM parser, set line count to zero etc */
  157.  
  158.     while ( !errflg && (ifmtoken = get_ifm_token(ifmfp, ifmword)) != 0) {
  159.     /* line format is:
  160.        Comment -I- CC <ifm> n ; PCC <pscharnum> <deltax> <deltay> ;
  161.        Comment -I- CCADD <newifmname> ;
  162.        Comment -I- CCS <ifmname> <otherifmname> ;
  163.      */
  164.  
  165.     switch (ifmtoken) {
  166.     case FONT_IFMTAG:
  167.  
  168.         /* example: Comment -I- FONT marathi devnac.afm */
  169.         ifmtoken = get_ifm_token(ifmfp, ifmword);
  170.         if (ifmtoken != DNAME_IFMTAG) {
  171.         fprintf(stderr, "Error in parsing ifm font metrics - expect a fontname after FONT\n");
  172.             errflg++; break;
  173.         }
  174.         strcpy(word, ifmword);
  175.         ifmtoken = get_ifm_token(ifmfp, ifmword);
  176.         if (ifmtoken != DNAME_IFMTAG) {
  177.         fprintf(stderr, "Error in parsing ifm font metrics - expect a filename after FONT %s\n", word);
  178.             errflg++; break;
  179.         }
  180.         strcpy(fmfname, ifmword);
  181.  
  182.         /* strip of path name stuff, and copy */
  183.         dp = strrchr(ifmfname, DIRSEP);
  184.         if (!dp) dp = ifmfname;
  185.         else dp++;
  186.         strcpy(font->fname, dp);
  187.  
  188.         strcpy(font->name, word);
  189.             /* -------- FILLUP ENCODING NAMES */
  190.             /* XXX - fill up font with G_ifm_map - maybe different
  191.          * fonts will use different names for ka, kha, etc!
  192.          * I hope not.
  193.          */
  194.             for (i = 0; i < NUMCHARS; i ++) {
  195.             font->enc[i] = G_ifm_map[i];
  196.             }
  197.  
  198.         /* fill in font Metrics */
  199.         strcpy(word, &ifmword[strlen(ifmword) - 3]); /* get last 3 chars */
  200.         if (!strcmp(word, "afm")) {
  201.         font->prop = TEX_PS_FONT; /* use font for both PostScript
  202.                        * and TeX output
  203.                        */
  204.         } else if (!strcmp(word, "tfm")) {
  205.         font->prop = TEX_FONT; /* use font for TeX output only */
  206.         } else  {
  207.         fprintf(stderr, "font.c::Error: illegal metric file name %s (must end in .afm or .tfm)\n", ifmword);
  208.             errflg++; break;
  209.         }
  210.  
  211.         if (font->prop == TEX_FONT) {
  212.  
  213.         /* dont read in any file, all TeX chars are non-zero
  214.          * widths anyway.
  215.          */
  216.         fmfp = NULL;
  217.         S_fillup_tfm(font);
  218.  
  219.         }  else {
  220.  
  221.         /* fill in PostScript Metrics */
  222.             fmfp = search_fopen(ienv, fmfname, "r");
  223.             if (!fmfp) {
  224.             fprintf(stderr, "font.c::Error: could not open %s for reading (afm)\n", fmfname);
  225.             errflg++; break;
  226.             } 
  227.         S_fillup_ps(fmfp, font);
  228.             fclose(fmfp);
  229.         }
  230.  
  231.         break;
  232.  
  233.     case PROP_IFMTAG:
  234.         if (!S_prop(ifmfp, font)) {
  235.         fprintf(stderr,"**** line %d - illegal PROP line\n", G_ifm_lineno);
  236.             errflg++;
  237.         }
  238.         break;
  239.  
  240.     case CCADD_IFMTAG:
  241.         if (!S_ccadd(ifmfp)) {
  242.         fprintf(stderr,"**** line %d - illegal CCADD line (last token %s)\n",
  243.             G_ifm_lineno, ifmword);
  244.             errflg++;
  245.         }
  246.         break;
  247.  
  248.     case CCS_IFMTAG:
  249.         if (!S_ccs(ifmfp, font)) {
  250.         fprintf(stderr,"**** line %d - illegal CCS line (last token %s)\n",
  251.             G_ifm_lineno, ifmword);
  252.             errflg++;
  253.         }
  254.         break;
  255.     case CC_IFMTAG:
  256.         if (!S_cc(ifmfp, font)) {
  257.         fprintf(stderr,"**** line %d - illegal CC line (last token %s)\n",
  258.             G_ifm_lineno, ifmword);
  259.             errflg++;
  260.         }
  261.         break;
  262.     case COMMENT_IFMTAG:
  263.         break;
  264.     default:
  265.         fprintf(stderr,"**** around line %d (+-1) - warning: unrecognized IFM token %s\n",
  266.             G_ifm_lineno, ifmword);
  267.         if (ifmtoken == PCC_IFMTAG)
  268.             fprintf(stderr,"**** around line %d (+-1) - warning: maybe the CC count is incorrect -- too many PCC's\n",
  269.             G_ifm_lineno);
  270.         break;
  271.     } /* switch */
  272.  
  273.     } /* while get_ifm_token(ifmfp, ifmword) - reading in IFM statements */
  274.  
  275.     /* clear any CCADD's this file may have added, so that each IFM
  276.      * file can use upto NUMEXTRA CCADD codenames.
  277.      * Without this clearing, the TOTAL number of CCADD statements in
  278.      * ALL the IFM files is limited to NUMEXTRA, this way, EACH file
  279.      * can use upto NUMEXTRA codenames...
  280.      */
  281.     S_clear_ccadds();
  282.  
  283.     if (!errflg) return TRUE;
  284.     else return FALSE;
  285. } /* fillup_font() */
  286.     
  287. /* ==================================================================== */
  288. static int S_fillup_ps(FILE* afmfp, font_t* font)
  289. {
  290.     int        i;
  291.     pschar_t*    psch;
  292.     char    line_in[LINELEN], *inc;
  293.  
  294.     /* fill up the postscript font metrics */
  295.  
  296.     psch = font->psfm;
  297.     while (fgets(line_in, LINELEN, afmfp)) {
  298.     /* line format is: C 33; WX 301; N exclam; B 93 -9 207 685; */
  299.  
  300.     if (line_in[0] != 'C' || line_in[1] != ' ') continue;
  301.     inc = &line_in[1];
  302.  
  303.         /* read in character code */
  304.     if (sscanf(inc, "%d", &i) != 1 || i < 0 || i >= NUMPSCHARS) {
  305.         fprintf(stderr, "Warning: illegal line <%s> in AFM file\n", line_in);
  306.         continue;
  307.     }
  308.  
  309.     inc = strchr(inc, 'W'); /* look for W.... */
  310.     inc = strchr(inc, ' '); /* look for <space> after W.... */
  311.  
  312.     sscanf(inc, "%d", &psch[i].w); /* read in width */
  313.  
  314.     inc = strrchr(inc, 'B'); /* look for ....B */
  315.     inc = strchr(inc, ' '); /* look for <space> after ..B */
  316.  
  317.         /* read in bounding box */
  318.     if (sscanf(inc, "%d%d%d%d", &psch[i].llx, &psch[i].lly, &psch[i].urx, &psch[i].urx) != 4) {
  319.         fprintf(stderr, "Warning: illegal B values - line <%s> in AFM file\n", line_in);
  320.     }
  321.  
  322.     } /* while fgets() */
  323.  
  324.     return TRUE;
  325. }
  326. /* ==================================================================== */
  327. /* this func does nothing, TeX never has zero width fonts (??) */
  328. static int S_fillup_tfm(font_t* font)
  329. {
  330.     pschar_t*    psch;
  331.     int i;
  332.  
  333.     /* fill up the TeX font metrics */
  334.  
  335.     psch = font->psfm;
  336.     for (i = 0 ; i < NUMPSCHARS; i ++ ) {
  337.  
  338.     psch[i].w = -1; /* just some non-zero value, unused really..*/
  339.             /* make it non-zero so that ichar.c::S_add_cus()
  340.              * is fooled into thinking that all chars have
  341.              * non-zero width, and it does not have to apply
  342.              * a reverse delta to back up
  343.              * Of course, this implies that until I get code
  344.              * here to actually read in the TFM's, the IFM
  345.              * file should have data to do all the backing up
  346.              * that may be necessary.
  347.              * 13 Aug Note: I did get the code, but
  348.              * all fonts seemed to have non-zero widths
  349.              * anyway..
  350.              * ...
  351.              * Maybe this backup on zero width chars
  352.              * was a bad idea anyway..
  353.              */
  354.     psch[i].llx = psch[i].lly = psch[i].urx = psch[i].urx = 0;
  355.  
  356.     }
  357.     return TRUE;
  358. }
  359. /* ==================================================================== */
  360. /* line format: Comment -I- CCADD <newifmname> ; */
  361. static int S_icurrextra = 0;
  362. static int S_ccadd(FILE* ifmfp)
  363. {
  364.  
  365.     int ifmtoken;
  366.     char word[256];
  367.     int cctype, ccl0, ccl1, ccform;
  368.     char    ifmword[256];
  369.  
  370.     ifmtoken = get_ifm_token(ifmfp, ifmword);
  371.     if (ifmtoken != DNAME_IFMTAG) {
  372.     fprintf(stderr, "Error in parsing indian font metrics - expect a word after CCADD\n");
  373.         return FALSE;
  374.     }
  375.     strcpy(word, ifmword);
  376.  
  377.     /* decode ifm name */
  378.     cctype = decode_name(word, &ccl0, &ccl1, &ccform);
  379.     if (cctype) {
  380.     /* some other ifm file also used this codename, so no need to add
  381.      * it again....
  382.      */
  383. #ifdef DEBUG
  384.     fprintf(stderr, "Note: new codename :%s: - already exists in khadi\n", word);
  385. #endif /* DEBUG */
  386.     return TRUE;
  387.     }
  388.  
  389.     /* check for overflow ... */
  390.     if (S_icurrextra >= NUMEXTRA) {
  391.     fprintf(stderr, "(line %d) Fatal Error in parsing indian font metrics - too many user-defined codenames\n", G_ifm_lineno);
  392.     exit(10);
  393.     }
  394.  
  395.     S_ifm_extra_map[S_icurrextra].token = LASTCHAR+1 + S_icurrextra;
  396.     strncpy(S_ifm_extra_map[S_icurrextra].codename, word, CNAMELEN);
  397.     S_ifm_extra_map[S_icurrextra].codename[CNAMELEN-1] = '\0';
  398.     S_icurrextra++;
  399. #ifdef DEBUG
  400. fprintf(stderr, "added CCADD tag, word is %s, tok %d (num %d)\n", S_ifm_extra_map[S_icurrextra-1].codename,S_ifm_extra_map[S_icurrextra-1].token, S_icurrextra);
  401. #endif /* DEBUG */
  402.     return TRUE;
  403.  
  404. } /* S_ccadd */
  405.  
  406. /* clear all the codenames added here (to prepare for the next IFM
  407.  * file, this function called at the end of fillup_font()
  408.  */
  409. static void S_clear_ccadds()
  410. {
  411.     int i;
  412.  
  413.     S_icurrextra = 0;
  414.     for (i = 0; i < NUMEXTRA; i ++) {
  415.     S_ifm_extra_map[i].codename[0] = '\0';
  416.     S_ifm_extra_map[i].token = -999;
  417.     }
  418. }
  419. /* ==================================================================== */
  420. /* line format:
  421. Comment -I- CC <ifmname> n ; PCC <pscharnum> <deltax> <deltay> ;
  422.  */
  423. static int S_cc(FILE* ifmfp, font_t *font)
  424. {
  425.     int i, j, ifmtoken;
  426.     char word[256];
  427.     int cctype, ccl0, ccl1, ccform;
  428.     int isconsd;
  429.     comp_unit_t*    pcu;
  430.     comp_unit_t**    ppcu;
  431.     int numpcc, pcode, dx, dy;
  432.     char    ifmword[256];
  433.  
  434.     isconsd = FALSE;
  435.     ifmtoken = get_ifm_token(ifmfp, ifmword);
  436.     if (ifmtoken != DNAME_IFMTAG) {
  437.     fprintf(stderr, "(line %d, token %d) Error in parsing indian font metrics - expect a word after CC\n", G_ifm_lineno, ifmtoken);
  438.         return FALSE;
  439.     }
  440.     strcpy(word, ifmword);
  441.  
  442.     cctype = decode_name(word, &ccl0, &ccl1, &ccform);
  443.     if (!cctype) {
  444.     fprintf(stderr, "Error: CC: illegal codename :%s:\n", word);
  445.     return FALSE;
  446.     }
  447.  
  448.     if (cctype == CONSONANT_DOUBLE_TYPE) isconsd = TRUE;
  449.  
  450. #ifdef DEBUG
  451.     fprintf(stderr, "name: %s, decoded %d %d %d type %d\n", word, ccl0, ccl1, ccform,cctype);
  452. #endif /* DEBUG */
  453.  
  454.     /* look for n - number of PCC segments */
  455.     ifmtoken = get_ifm_token(ifmfp, ifmword);
  456.     if (ifmtoken != NUMBER_IFMTAG) {
  457.     fprintf(stderr, "(line %d, token %d yytesxt %s) Error in parsing indian font metrics - expect a number after CC word.. \n", G_ifm_lineno, ifmtoken, ifmword);
  458.         return FALSE;
  459.     }
  460.     word[0] = 0; strcpy(word, ifmword);
  461.     if (sscanf(word, "%d", &numpcc) != 1) {
  462.     fprintf(stderr, "Warning: (line %d) illegal value in IFM file (looking for number of PCC segments)\n", G_ifm_lineno);
  463.     return FALSE;
  464.     }
  465.  
  466.     if (isconsd) {
  467.     ppcu = font->ligatures[ccl0][ccl1].cus;
  468.     } else {
  469.     ppcu = font->khadi[ccl0].cus;
  470.     }
  471.     if (!ppcu) { /* first time, allocate */
  472.     ppcu = (comp_unit_t**) malloc(NUMFORMS*sizeof(*ppcu));
  473.     if (isconsd) {
  474.         font->ligatures[ccl0][ccl1].cus = ppcu;
  475.     } else  {
  476.         font->khadi[ccl0].cus = ppcu;
  477.     }
  478.     for (i = 0; i < NUMFORMS; i ++) {
  479.         ppcu[i] = (comp_unit_t*) NULL;
  480.     }
  481.     }
  482.     pcu = (comp_unit_t*) malloc(numpcc*sizeof(*pcu));
  483.     if (isconsd) {
  484.     font->ligatures[ccl0][ccl1].cus[ccform] = pcu;
  485.     /*
  486.     fprintf(stderr, "fillip: filling ligature %d %d %d\n", ccl0, ccl1, ccform);
  487.     */
  488.     } else {
  489.     font->khadi[ccl0].cus[ccform] = pcu;
  490.     }
  491.  
  492. #ifdef DEBUG
  493.     fprintf(stderr, "filling up PCC's for ccl0 %d l1 %d form %d type %d\n",
  494.     ccl0, ccl1, ccform, cctype);
  495. #endif /* DEBUG */
  496.  
  497.     for (i = 0; i < numpcc; i ++) {
  498.  
  499.     /* look for " ; PCC" */
  500.         ifmtoken = get_ifm_token(ifmfp, ifmword);
  501.         if (ifmtoken != PCC_IFMTAG) {
  502.         fprintf(stderr, "(line %d, token %d ifmword %s)Error in parsing indian font metrics - expect a PCC tag\n", G_ifm_lineno, ifmtoken, ifmword);
  503.             return FALSE;
  504.         }
  505.  
  506.         /* defaults */
  507.     pcu->u_pschar = NO_PSCHAR;
  508.     pcu->dorg = DORG_CLR;
  509.     pcu->deltax = 0;
  510.     pcu->deltay = 0;
  511.     if (i == (numpcc - 1)) pcu->next = NULL; /* last comp_unit ... */
  512.     else pcu->next = pcu + 1; /* point to next comp_unit ... */
  513.  
  514.         ifmtoken = get_ifm_token(ifmfp, ifmword);
  515.         word[0] = 0; strcpy(word, ifmword);
  516.     if (ifmtoken == IMPLICIT_IFMTAG) {
  517.         pcode = IMPLICIT_PSCHAR;
  518.     } else if (ifmtoken == NONE_IFMTAG) {
  519.         pcode = NO_PSCHAR;
  520.     } else if (ifmtoken == NUMBER_IFMTAG) {
  521.         j = sscanf(word, "%d", &pcode);
  522.     } else {
  523.         fprintf(stderr, "(line %d, token %d %s)Error in parsing indian font metrics - expect a number after PCC tag\n", G_ifm_lineno, ifmtoken, ifmword);
  524.         return FALSE;
  525.         }
  526.  
  527.         /* point to dx, could be %d or s%d */
  528.     ifmtoken = get_ifm_token(ifmfp, ifmword);
  529.     if (ifmtoken == DELTAS_IFMTAG) {
  530.         pcu->dorg = DORG_LL;
  531.         fprintf(stderr, "Error: s+/- option not supported in Devn Metrics - ignoring it\n");
  532.         ifmword[0] = ' ';  /* replace "s" with space, number is read
  533.                 * by scanf
  534.                 */
  535.     } else if (ifmtoken != NUMBER_IFMTAG) {
  536.         fprintf(stderr, "Error in parsing indian font metrics - expect a number after PCC ...\n");
  537.             return FALSE;
  538.         }
  539.         word[0] = 0; strcpy(word, ifmword);
  540.     j = sscanf(word, "%d", &dx);
  541.  
  542.     ifmtoken = get_ifm_token(ifmfp, ifmword);
  543.         /* point to dy, has to be %d (s%d not supported yet) */
  544.         /* no need to support s+70 or s-70 etc since height
  545.          * of char is constant - cannot be modified for 
  546.          * roman/devnagari/like scripts.
  547.          */
  548.         if (ifmtoken != NUMBER_IFMTAG) {
  549.         fprintf(stderr, "Error in parsing indian font metrics - expect a number after PCC ... dx ..\n");
  550.             return FALSE;
  551.         }
  552.         word[0] = 0; strcpy(word, ifmword);
  553.     j += sscanf(word, "%d", &dy);
  554.  
  555.     if (j != 2) {
  556.         fprintf(stderr, "Warning: IFM file - illegal dx/dy values-\n");
  557.     } else {
  558.         pcu->u_pschar = pcode;
  559.         pcu->deltax = dx;
  560.         pcu->deltay = dy;
  561.     }
  562.  
  563.     /* check for errors: if NO_PSCHAR, then dy must be zero */
  564.     if (pcode == NO_PSCHAR && dy != 0) {
  565.         fprintf(stderr, "(line %d)Warning PCC none .. must have dy == 0, will make it 0\n",
  566.             G_ifm_lineno);
  567.         pcu->deltay = 0;
  568.     }
  569.  
  570. #ifdef DEBUG
  571.     fprintf(stderr, "pcode %d dx %d dy %d\n", pcode, dx, dy);
  572. #endif /* DEBUG */
  573.  
  574.     pcu++;
  575.     } /* for i numpcc */
  576.  
  577.     return TRUE;
  578. } /* S_cc */
  579. /* ==================================================================== */
  580. /* line format: Comment -I- CCS <ifmname> <otherifmname> ; */
  581. static int S_ccs(FILE* ifmfp, font_t *font)
  582. {
  583.     int ifmtoken;
  584.     char word[256];
  585.     int cctype, ccl0, ccl1, ccform;
  586.     int pcctype, pccl0, pccl1, pccform;
  587.     dchar_t*        dptr;
  588.     int            i;
  589.     char    ifmword[256];
  590.  
  591.     ifmtoken = get_ifm_token(ifmfp, ifmword);
  592.     if (ifmtoken != DNAME_IFMTAG) {
  593.     fprintf(stderr, "(line %d, token %d) Error in parsing indian font metrics - expect a word after CCS\n", G_ifm_lineno, ifmtoken);
  594.         return FALSE;
  595.     }
  596.     strcpy(word, ifmword);
  597.  
  598.     cctype = decode_name(word, &ccl0, &ccl1, &ccform);
  599.     if (!cctype) {
  600.     fprintf(stderr, "Error: CCS:cc: illegal codename :%s:\n", word);
  601.     return FALSE;
  602.     }
  603. #ifdef DEBUG
  604. fprintf(stderr, "got CCS tag, word is %s type %d\n", word, cctype);
  605. #endif /* DEBUG */
  606.  
  607.     ifmtoken = get_ifm_token(ifmfp, ifmword);
  608.     if (ifmtoken != DNAME_IFMTAG) {
  609.     fprintf(stderr, "(line %d, token %d) Error in parsing indian font metrics - expect a second word after CCS\n", G_ifm_lineno, ifmtoken);
  610.         return FALSE;
  611.     }
  612.     strcpy(word, ifmword);
  613.  
  614.     pcctype = decode_name(word, &pccl0, &pccl1, &pccform);
  615.     if (!pcctype) {
  616.     fprintf(stderr, "Error: CCS: pcc: illegal codename :%s:\n", word);
  617.     return FALSE;
  618.     }
  619. #ifdef DEBUG
  620. fprintf(stderr, "otherifmname is %s \n", word);
  621. #endif /* DEBUG */
  622.     dptr = NULL;
  623.     if (pcctype == CONSONANT_DOUBLE_TYPE) {
  624.     if (pccl0 == ALL_CHARS || pccl1 == ALL_CHARS) {
  625.         fprintf(stderr, "Error: <otherifmname> (line %d) in CCS should not contain *'s\n", G_ifm_lineno);
  626.         return FALSE;
  627.     } else {
  628.         dptr = &font->ligatures[pccl0][pccl1];
  629.     }
  630.     } else {
  631.     if (cctype == CONSONANT_SINGLE_TYPE && pccl0 == ALL_CHARS) {
  632.         fprintf(stderr, "Error: <otherifmname> (line %d) in CCS must be a single khadi cannot be *.\n", G_ifm_lineno);
  633.         return FALSE;
  634.     } else {
  635.         if (pccl0 != ALL_CHARS) dptr = &font->khadi[pccl0];
  636.     }
  637.     }
  638.     if (cctype == CONSONANT_DOUBLE_TYPE) {
  639. #ifdef DEBUG
  640. fprintf(stderr, "ligatures %d %d %d same as %d %d\n", ccl0, ccl1, ccform, pccl0, pccl1);
  641. #endif /* DEBUG */
  642.     if (ccl0 == ALL_CHARS) {
  643.         if (pccl0 == ALL_CHARS) {
  644.         for (i = FIRSTCONS; i < NUMCHARS; i ++)
  645.             font->ligatures[i][ccl1].same_as = &font->khadi[i];
  646.         } else {
  647.         for (i = FIRSTCONS; i < NUMCHARS; i ++)
  648.             font->ligatures[i][ccl1].same_as = dptr;
  649.         }
  650.     } else if (ccl1 == ALL_CHARS) {
  651.         if (pccl0 == ALL_CHARS) {
  652.         for (i = FIRSTCONS; i < NUMCHARS; i ++)
  653.             font->ligatures[ccl0][i].same_as = &font->khadi[i];
  654.         } else {
  655.         for (i = FIRSTCONS; i < NUMCHARS; i ++)
  656.             font->ligatures[ccl0][i].same_as = dptr;
  657.         }
  658.     } else {
  659.         font->ligatures[ccl0][ccl1].same_as = dptr;
  660.     }
  661.     } else {
  662. #ifdef DEBUG
  663. fprintf(stderr, "khadi %d %d same as %d %d\n", ccl0, ccl1, pccl0, pccl1);
  664. #endif /* DEBUG */
  665.     font->khadi[ccl0].same_as = dptr;
  666.     }
  667.  
  668.     return TRUE;
  669. } /* S_ccs() */
  670.  
  671. /* ==================================================================== */
  672. /* Given a word referring to a full indian language character, decode
  673.  * it into its letter and form parts.
  674.  * For ex:
  675.  * ka-i        is letter "ka" (KA_TOK) and form "i" (I_FORM)
  676.  * a        is letter "a" (A_TOK) and form "a" (A_FORM)
  677.  * am        is letter "am" (AM_TOK) and form "a" (A_FORM)
  678.  * ksha-half    is letter "ksha" (KSHA_TOK) and form (HALF_FORM)
  679.  * da-dha    is (half) letter "da" (DA_TOK) and full letter dha (DHA_TOK)
  680.  * etc
  681.  * Function returns type: VOWEL_TYPE, CONSONANT_SINGLE_TYPE, 
  682.  * CONSONANT_DOUBLE_TYPE or 0 for error
  683.  */
  684.  
  685. int decode_name(char inword[], int* firstc, int* secondc, int* form)
  686. {
  687.     char word[256], word1[256], word2[256], word3[256];
  688.     char *start;
  689.     int i, l0, l1, f, t;
  690.  
  691.     word1[0] = '\0'; word2[0] = '\0'; word3[0] = '\0';
  692.     l0 = l1 = f = NO_CHAR;
  693.     t = 0;
  694.     *firstc = *secondc = *form = NO_CHAR;
  695.  
  696.     strcpy(word, inword);
  697.     start = strtok(word, "-");
  698.     if (!start) return 0; /* ERROR */
  699.     strcpy(word1, start); /* first word is in here now */
  700.  
  701.     if ((start = strtok(NULL, "-")) != NULL) { /* look for second word */
  702.         strcpy(word2, start); /* second word is in here now */
  703.         if ((start = strtok(NULL, "-")) != NULL) { /* look for third word */
  704.             strcpy(word3, start); /* third word is in here now */
  705.         }
  706.     }
  707.  
  708. #ifdef DEBUG
  709. fprintf(stderr, "decoding: word 1 :%s:, 2 :%s:, 3 :%s:\n", word1, word2,
  710. word3);
  711. #endif /* DEBUG */
  712.  
  713.     /* look for l0, could be vowel, cons, or user-defined cons (extra_map) */
  714.     for (i = 0; i < NUMCHARS; i ++) {
  715.     if (!strcmp(G_ifm_map[i].codename, word1)) {
  716.         l0 = i; break;
  717.     }
  718.     }
  719.     if (l0 < 0) {
  720.         for (i = 0; i < NUMEXTRA; i ++) {
  721.         if (!strcmp(S_ifm_extra_map[i].codename, word1)) {
  722.             l0 = S_ifm_extra_map[i].token; break;
  723.         }
  724.         }
  725.     }
  726.     if (l0 < 0) {
  727.     if (!strcmp("*", word1)) {
  728.         l0 = ALL_CHARS;
  729.     }
  730.     }
  731.  
  732.     /* look for l1, must be vowel or cons or allchars */
  733.     if (word2[0]) {
  734.         if (!strcmp("half", word2)) {
  735.         l1 = HALF_FORM;
  736.         } else if (!strcmp("implicit", word2)) {
  737.         l1 = IMPLICIT_FORM;
  738.         } else {
  739.             for (i = 0; i < NUMCHARS; i ++) {
  740.             if (!strcmp(G_ifm_map[i].codename, word2)) {
  741.                 l1 = i; break;
  742.             }
  743.             }
  744.     }
  745.     }
  746.     if (l1 < 0) {
  747.     if (!strcmp("*", word2)) {
  748.         l1 = ALL_CHARS;
  749.     }
  750.     }
  751.  
  752.  
  753.     /* look for form, must be vowel */
  754.     if (word3[0]) {
  755.         if (!strcmp("half", word3)) {
  756.         f = HALF_FORM;
  757.         } else if (!strcmp("implicit", word3)) {
  758.         f = IMPLICIT_FORM;
  759.         } else {
  760.             for (i = 0; i <= AHA_FORM; i ++) {
  761.             if (!strcmp(G_ifm_map[i].codename, word3)) {
  762.                 f = i; break;
  763.             }
  764.             }
  765.     }
  766.     }
  767.  
  768.     /* DECODE IT */
  769.     if (l0 >= ALL_CHARS && (l1 >= FIRSTCONS || l1 == ALL_CHARS) &&
  770.         strcmp(word2, "half") && strcmp(word2, "implicit")) {
  771.     /* is a double consonant with possible form (may be absent) */
  772.     /* only if the second word was not half or implicit */
  773.         t = CONSONANT_DOUBLE_TYPE;
  774. #ifdef DEBUG
  775.    fprintf(stderr, "defined as DOUBLE: t is %d\n", t);
  776. #endif /* DEBUG */
  777.         if (f < A_FORM || f > IMPLICIT_FORM) {
  778. #ifdef DEBUG
  779.         fprintf(stderr, "Warning: Double Consonants (ligatures) must have a valid form (Unless this is a CCS statement!) - assuming IMPLICIT here (%s)\n", inword);
  780. #endif /* DEBUG */
  781.         f = IMPLICIT_FORM;
  782.         }
  783.     } else if (l0 >= FIRSTVOW && l0 <= LASTVOW) {
  784.         /* check if l0 is a vowel */
  785.     f = A_FORM; /* vowels are always one word only */
  786.     l1 = NO_CHAR;
  787.     t = VOWEL_TYPE;
  788.     } else if (l0 >= 0) {
  789.         /* must be single cons type, code is two words only */
  790.         f = l1;
  791.     l1 = NO_CHAR;
  792.         if (l0 > LASTCONS && l0 <= LASTCHAR) {
  793.         t = SPECIAL_TYPE;
  794.         if (f != IMPLICIT_FORM) fprintf(stderr, "Warning: All Specials must have IMPLICIT_FORM only (%s)\n", inword);
  795.         f = IMPLICIT_FORM;
  796.         } else {
  797.         t = CONSONANT_SINGLE_TYPE;
  798.         }
  799.     } else if (l0 == ALL_CHARS) {
  800.     f = NO_CHAR; /* vowels are always one word only */
  801.     l1 = NO_CHAR;
  802.     t = CONSONANT_SINGLE_TYPE;
  803. #ifdef DEBUG
  804.    fprintf(stderr, "l0 is ALL_CHARS, defined as SINGLE: t is %d\n", t);
  805. #endif /* DEBUG */
  806.     } /* else is a new userdefined char */
  807.  
  808.     *firstc = l0;
  809.     *secondc = l1;
  810.     *form = f;
  811.  
  812.  
  813. #ifdef DEBUG
  814.     fprintf(stderr, "decode l0 %d l1 %d f %d returning %d, f %d s %d form %d\n",
  815. l0, l1, f, t, *firstc, *secondc, *form);
  816.     if (*form < 0) {
  817.     fprintf(stderr, "WARNING: form is NEGATIVE: %d (%s)\n", *form, inword);
  818.     }
  819. #endif /* DEBUG */
  820.     return t;
  821. }
  822.  
  823. /* ==================================================================== */
  824. /* The encoding map: BE CAREFUL of changing the size of this
  825.  * array - MUST always reflect the NUMCHARS defined value in imap.h
  826.  * this array is GLOBAL, error handling in ichar.c (missing chars)
  827.  * uses this data
  828.  * NOTE:
  829.  * All names must be distinct (see imap.h) and the order of
  830.  * tokens here MUST be the same as in y.tab.h
  831.  */
  832. ifm_enc_t G_ifm_map[NUMCHARS] = {
  833.     /* 0 */    A_TOK,        A_CNAME,
  834.     /* 1 */    AA_TOK,        AA_CNAME,
  835.     /* 2 */    I_TOK,        I_CNAME,
  836.     /* 3 */    II_TOK,        II_CNAME,
  837.     /* 4 */    U_TOK,        U_CNAME,
  838.     /* 5 */    UU_TOK,        UU_CNAME,
  839.     /* 6 */    RI_TOK,        RI_CNAME,
  840.     /* 7 */    RII_TOK,    RII_CNAME,
  841.     /* 8 */    LI_TOK,        LI_CNAME,
  842.     /* 9 */    LII_TOK,    LII_CNAME,
  843.     /* 10 */    AY_TOK,        AY_CNAME,
  844.     /* 10 */    AAY_TOK,    AAY_CNAME,
  845.     /* 11 */    AI_TOK,        AI_CNAME,
  846.     /* 12 */    O_TOK,        O_CNAME,
  847.     /* 12 */    OO_TOK,        OO_CNAME,
  848.     /* 13 */    AU_TOK,        AU_CNAME,
  849.     /* 14 */    AM_TOK,        AM_CNAME,
  850.     /* 15 */    AHA_TOK,    AHA_CNAME,
  851.     /* 16 */    KA_TOK,        KA_CNAME,
  852.     /* 17 */    KHA_TOK,    KHA_CNAME,
  853.     /* 18 */    GA_TOK,        GA_CNAME,
  854.     /* 19 */    GHA_TOK,    GHA_CNAME,
  855.     /* 20 */    NGA_TOK,    NGA_CNAME,
  856.     /* 21 */    CHA_TOK,    CHA_CNAME,
  857.     /* 22 */    CHHA_TOK,    CHHA_CNAME,
  858.     /* 23 */    JA_TOK,        JA_CNAME,
  859.     /* 24 */    JHA_TOK,    JHA_CNAME,
  860.     /* 25 */    JNH_TOK,    JNH_CNAME,
  861.     /* 26 */    TTA_TOK,    TTA_CNAME,
  862.     /* 27 */    TTHA_TOK,    TTHA_CNAME,
  863.     /* 28 */    DDA_TOK,    DDA_CNAME,
  864.     /* 29 */    DDHA_TOK,    DDHA_CNAME,
  865.     /* 30 */    NNA_TOK,    NNA_CNAME,
  866.     /* 31 */    TA_TOK,        TA_CNAME,
  867.     /* 32 */    THA_TOK,    THA_CNAME,
  868.     /* 33 */    DA_TOK,        DA_CNAME,
  869.     /* 34 */    DHA_TOK,    DHA_CNAME,
  870.     /* 35 */    NA_TOK,        NA_CNAME,
  871.     /* 36 */    PA_TOK,        PA_CNAME,
  872.     /* 37 */    PHA_TOK,    PHA_CNAME,
  873.     /* 38 */    BA_TOK,        BA_CNAME,
  874.     /* 39 */    BHA_TOK,    BHA_CNAME,
  875.     /* 40 */    MA_TOK,        MA_CNAME,
  876.     /* 41 */    YA_TOK,        YA_CNAME,
  877.     /* 42 */    RA_TOK,        RA_CNAME,
  878.     /* 43 */    LA_TOK,        LA_CNAME,
  879.     /* 44 */    VA_TOK,        VA_CNAME,
  880.     /* 45 */    SHA_TOK,    SHA_CNAME,
  881.     /* 46 */    SHHA_TOK,    SHHA_CNAME,
  882.     /* 47 */    SA_TOK,        SA_CNAME,
  883.     /* 48 */    HA_TOK,        HA_CNAME,
  884.     /* 49 */    LDA_TOK,    LDA_CNAME,
  885.     /* 50 */    KSHA_TOK,    KSHA_CNAME,
  886.     /* 51 */    GYA_TOK,    GYA_CNAME,
  887.     /* 52 */    NNX_TOK,    NNX_CNAME,
  888.     /* 53 */    NYA_TOK,    NYA_CNAME,
  889.     /* 54 */    RRA_TOK,    RRA_CNAME,
  890.     /* 55 */    KADOT_TOK,    KADOT_CNAME,
  891.     /* 56 */    KHADOT_TOK,    KHADOT_CNAME,
  892.     /* 57 */    GADOT_TOK,    GADOT_CNAME,
  893.     /* 58 */    DDADOT_TOK,    DDADOT_CNAME,
  894.     /* 59 */    DDHADOT_TOK,    DDHADOT_CNAME,
  895.     /* 50 */    JADOT_TOK,    JADOT_CNAME,
  896.     /* 61 */    PHADOT_TOK,    PHADOT_CNAME,
  897.     /* 62 */    RA_HALF_TOK,    RA_HALF_CNAME,
  898.     /* 63 */    ANUSVARA_TOK,    ANUSVARA_CNAME,
  899.     /* 64 */    CHANDRA_TOK,     CHANDRA_CNAME,
  900.     /* 65 */    CHANDRA_BN_TOK, CHANDRA_BN_CNAME,
  901.     /* 66 */    VIRAAM_TOK,    VIRAAM_CNAME,
  902.     /* 67 */    AVAGRAHA_TOK,    AVAGRAHA_CNAME,
  903.     /* 68 */    SRI_TOK,     SRI_CNAME,
  904.     /* 69 */    AUM_TOK,     AUM_CNAME,
  905. };
  906.  
  907. /* =================================================================== */
  908. /* print out font data (for debugging) */
  909. void dump_font(font_t* font, FILE* outfp)
  910. {
  911.     int i, j;
  912.     comp_unit_t* cus;
  913.  
  914.     fprintf(outfp, "font prop: %d\n", font->prop);
  915.     fprintf(outfp, "font name: %s\n", font->name);
  916.  
  917.     for (i = 0; i < NUMKHADI; i ++) {
  918.     if (font->khadi[i].cus) {
  919.         cus = font->khadi[i].cus[IMPLICIT_FORM];
  920.         if (!cus) cus = font->khadi[i].cus[A_FORM];
  921.     }
  922.     if (!cus && font->khadi[i].same_as && !font->khadi[i].same_as->cus[IMPLICIT_FORM])
  923.         continue;
  924.  
  925.     fprintf(outfp, "Form a/implicit: Character %d, ", i);
  926.     fprintf(outfp, "name: %s\n", font->enc[i].codename);
  927.  
  928.     while (cus) { /* NULL test */
  929.         fprintf(stderr, " cus: pschar %d, delta %d %d; ",
  930.             (cus)->u_pschar, (cus)->deltax, (cus)->deltay);
  931.         cus = cus->next;
  932.     }
  933.     cus = NULL; 
  934.     if (font->khadi[i].same_as) cus = font->khadi[i].same_as->cus[IMPLICIT_FORM];
  935.     while (cus) { /* NULL test */
  936.         fprintf(outfp, " cus: pschar %d, delta %d %d; ",
  937.             (cus)->u_pschar, (cus)->deltax, (cus)->deltay);
  938.         cus = cus->next;
  939.     }
  940.     fprintf(outfp, "\n");
  941.     }
  942.  
  943.     for (i = 0; i < NUMCHARS; i ++) {
  944.         for (j = 0; j < NUMCHARS; j ++) {
  945.         /* font->ligatures[i][j].cus = NULL;
  946.         font->ligatures[i][j].same_as = NULL;
  947.         */
  948.         }
  949.     }
  950.     for (i = 0; i < 10; i ++) {
  951.     /*
  952.     font->digits[i].cus = NULL;
  953.     font->digits[i].same_as = NULL;
  954.     */
  955.     }
  956.  
  957.     for (i = 0; i < NUMPSCHARS; i ++) {
  958.     if (font->psfm[i].w > 0) {
  959.     fprintf(outfp, "char %d:: width %d ", i, font->psfm[i].w);
  960.     fprintf(outfp, "llx %d ", font->psfm[i].llx);
  961.     fprintf(outfp, "lly %d ", font->psfm[i].lly);
  962.     fprintf(outfp, "urx %d ", font->psfm[i].urx);
  963.     fprintf(outfp, "ury %d\n", font->psfm[i].ury);
  964.     }
  965.     }
  966. } /* print_font() */
  967. /* ==================================================================== */
  968. /* line format: Comment -I- PROP %d ligatures ; ... */
  969. /* or Comment -I- PROP %d no_ligatures ; ... */
  970. static int S_prop(FILE* ifmfp, font_t* ft)
  971. {
  972.     int  i, n, ifmtoken;
  973.     char word[256];
  974.     char ifmword[256];
  975.  
  976.     /* look for n - number of property names */
  977.     ifmtoken = get_ifm_token(ifmfp, ifmword);
  978.     if (ifmtoken != NUMBER_IFMTAG) {
  979.     fprintf(stderr, "(line %d, token %d yytext %s) Error in parsing indian font metrics - expect a number after PROP word.. \n", G_ifm_lineno, ifmtoken, ifmword);
  980.         return FALSE;
  981.     }
  982.     word[0] = 0; strcpy(word, ifmword);
  983.     if (sscanf(word, "%d", &n) != 1) {
  984.     fprintf(stderr, "Warning: (line %d) illegal value in IFM file (looking for number of PROPerties)\n", G_ifm_lineno);
  985.     return FALSE;
  986.     }
  987.  
  988.     for (i = 0; i < n; i ++) {
  989.         ifmtoken = get_ifm_token(ifmfp, ifmword);
  990.         if (ifmtoken != DNAME_IFMTAG) {
  991.         fprintf(stderr, "Error in parsing indian font metrics - expect a word after PROP (line %d, i %d)\n", G_ifm_lineno, i);
  992.         return FALSE;
  993.         }
  994.         strcpy(word, ifmword);
  995.  
  996.         if (!strcmp(word, "no_ligatures")) {
  997.         ft->use_ligatures = FALSE;
  998.         } else if (!strcmp(word, "ligatures")) {
  999.         ft->use_ligatures = TRUE;
  1000.         } else {
  1001.         fprintf(stderr, "Error in parsing indian font metrics: PROP keyword (%s)  unrecognized (line %d)\n", word, G_ifm_lineno);
  1002.         }
  1003.     }
  1004.  
  1005.     return TRUE;
  1006. }
  1007. /* ===========================^ font.c ^ ============================== */
  1008.